////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2016-2018 Qualcomm Technologies, Inc.
// All Rights Reserved.
// Confidential and Proprietary - Qualcomm Technologies, Inc.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @file  camximagesensormoduledata.h
/// @brief Image sensor module data declaration
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef CAMXIMAGESENSORMODULEDATA_H
#define CAMXIMAGESENSORMODULEDATA_H

class   ImageSensorModuleSetManager;

CAMX_NAMESPACE_BEGIN

/// @todo (CAMX-79)  Add support to query static metadata from image module sensor data.

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Forward Declarations
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class   ImageSensorModuleData;
class   ImageSensorModuleDataManager;
class   CmdBuffer;
class   TuningDataManager;
class   ImageSensorData;
class   ActuatorData;
class   OISData;
class   FlashData;
class   PDAFData;
struct  CSIInformation;
struct  LensInformation;
struct  ActuatorDriverData;
struct  OISDriverData;
struct  CameraModuleData;
struct  FlashDriverData;
struct  PDAFConfigurationData;
struct  SensorModuleStaticCaps;
struct  HwSensorInfo;
struct  HwDeviceTypeInfo;
enum class PDAFType;

/// @brief Input/output data for creating an image sensor module data object.
struct ImageSensorModuleDataCreateData
{
    ImageSensorModuleData*          pImageSensorModuleData;  ///< Created ImageSensorModuleData object
    ImageSensorModuleSetManager*    pSensorModuleManagerObj; ///< Pointer to Sensor Module Manager object
    ImageSensorModuleDataManager*   pDataManager;            ///< Pointer to the data manager that created this
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Class that contains the image sensor module data.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class ImageSensorModuleData
{
public:
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Destroy
    ///
    /// @brief  Destroy the image sensor module data object.
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    VOID Destroy();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Create
    ///
    /// @brief  Create concrete image sensor module data object
    ///
    /// @param  pCreateData Image sensor module data create data
    ///
    /// @return The ImageSensorModuleData as the base node object.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static CamxResult Create(
        ImageSensorModuleDataCreateData* pCreateData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Probe
    ///
    /// @brief  Trigger probe for the camera image sensor and module.
    ///
    /// @param  pDetected       Will be set to TRUE if the image sensor module is detected, FALSE otherwise.
    /// @param  pDeviceIndex    Will be populated with the device index of the detected image sensor module.
    ///
    /// @return CamxResultSuccess if successful regardless of detected state.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult Probe(
        BOOL*   pDetected,
        INT32*  pDeviceIndex);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// CreateSensorSubModules
    ///
    /// @brief  Create and initialize all the sensor sub modules
    ///
    /// @param  pSensorInfoTable    Contains information of the all the probed sensors information.
    /// @param  pCSLDeviceTable     Contains information of the all the detected devices.
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    VOID CreateSensorSubModules(
        HwSensorInfo*           pSensorInfoTable,
        const HwDeviceTypeInfo* pCSLDeviceTable);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// CreateAndReadEEPROMData
    ///
    /// @brief  Create and initialize EEPROMData.
    ///
    /// @param  pSensorInfoTable    Contains information of the all the probed sensors information.
    /// @param  pCSLDeviceTable     Contains information of the EEPROM device table.
    /// @param  hCSL                Handle to the CSL session (If this is 0, EEPROMData will open new CSL session)
    ///
    /// @return Success or Failure
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult CreateAndReadEEPROMData(
        HwSensorInfo*           pSensorInfoTable,
        const HwDeviceTypeInfo* pCSLDeviceTable,
        CSLHandle               hCSL);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// DumpEEPROMData
    ///
    /// @brief  Dump EEPROM data.
    ///
    /// @param  pSensorInfoTable    Contains information of the all the probed sensors information.
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    VOID DumpEEPROMData(
        HwSensorInfo*           pSensorInfoTable);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetStaticCaps
    ///
    /// @brief  Get the static capabilities of this camera sensor. This method is valid only after probe.
    ///
    /// @param  pCapability       Will be populated with the capabilities of this image sensor module.
    /// @param  pTuningManager    Pointer to the Tuning Manager.
    ///
    /// @return CamxResultSuccess if successful.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult GetStaticCaps(
        SensorModuleStaticCaps* pCapability,
        TuningDataManager*      pTuningManager);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetOverrideSensorMountAvailable
    ///
    /// @brief  Query if UMD image sensor module data file has a valid sensor mount override.
    ///
    /// @return TRUE if override mount information is available.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL GetOverrideSensorMountAvailable();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetOverrideSensorMount
    ///
    /// @brief  Retrieve UMD image sensor module data mount override if available.
    ///
    /// @param  pRoll   Roll, can be used to determine the how sensor is orientated.
    /// @param  pPitch  Pitch of the camera.
    /// @param  pYaw    Yaw, can be used to determine front or back facing camera.
    ///
    /// @return CamxResultSuccess if successful.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult GetOverrideSensorMount(
        UINT32* pRoll,
        UINT32* pPitch,
        UINT32* pYaw);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetSensorDataObject
    ///
    /// @brief  Retrieve image sensor data object
    ///
    /// @return Pointer to ImageSensorData
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CAMX_INLINE ImageSensorData* GetSensorDataObject() const
    {
        return m_pSensorData;
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetActuatorDataObject
    ///
    /// @brief  Retrieve Actuator data object
    ///
    /// @return Pointer to ActuatorData
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CAMX_INLINE ActuatorData* GetActuatorDataObject() const
    {
        return m_pActuatorData;
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetOisDataObject
    ///
    /// @brief  Retrieve Ois data object
    ///
    /// @return Pointer to Ois
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CAMX_INLINE OISData* GetOisDataObject() const
    {
        return m_pOISData;
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetFlashDataObject
    ///
    /// @brief  Retrieve Flash data object
    ///
    /// @return Pointer to FlashData
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CAMX_INLINE FlashData* GetFlashDataObject()
    {
        return m_pFlashData;
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetActuatorSensitivity
    ///
    /// @brief  Retrieve actuator sensitivity
    ///
    /// @return actuator sensitivity
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT GetActuatorSensitivity();


    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetPDAFDataObj
    ///
    /// @brief  Retrieve PDAF data object
    ///
    /// @return Pointer to PDAFData
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CAMX_INLINE PDAFData* GetPDAFDataObj()
    {
        return m_pPDAFData;
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetCSIInfo
    ///
    /// @brief  Retrieve Lane Assign and Combo mode.
    ///
    /// @return pointer to CSI Information from module configration
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    const CSIInformation* GetCSIInfo() const;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetLensInfo
    ///
    /// @brief  Retrieve lens information for the module.
    ///
    /// @return address of Lens Information from module configuration
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    const LensInformation* GetLensInfo();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetChromatixName
    ///
    /// @brief  Retrieve chromatix name for the module.
    ///
    /// @return pointer to the chromatix name
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    const CHAR* GetChromatixName();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetCameraId
    ///
    /// @brief  Retrieve  camera Id for the module.
    ///
    /// @param  pCameraId Camera Id to be returned
    ///
    /// @return camera Id for this module from configuration
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult GetCameraId(
        UINT16* pCameraId) const;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// TranslateUsecaseMode
    ///
    /// @brief  Translate driver specific type to corresponding UMD type
    ///
    /// @param  type    Driver specific type.
    ///
    /// @return UMD type for sensor usecase mode
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static UsecaseMode TranslateUsecaseMode(
        INT32 type);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// TranslatePixelFormat
    ///
    /// @brief  Translate driver specific type to corresponding UMD type
    ///
    /// @param  type    Driver specific type.
    ///
    /// @return UMD type for pixel format
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static PixelFormat TranslatePixelFormat(
        INT32 type);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// IsExternalSensor
    ///
    /// @brief  Informs if this is an external sensor or not
    ///
    /// @return TRUE or FALSE
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL IsExternalSensor() const;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetPDAFInformation
    ///
    /// @brief  Get PDAF supported and type information.
    ///
    /// @param  modeIndex     Mode index.
    /// @param  pIsSupported  PDAF supported flag returned.
    /// @param  pPDType       PDAF type returned.
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    VOID GetPDAFInformation(
        UINT32    modeIndex,
        BOOL*     pIsSupported,
        PDAFType* pPDType) const;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetDataManager
    ///
    /// @brief  Informs if this is an external sensor or not
    ///
    /// @return pointer to the data manager
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CAMX_INLINE ImageSensorModuleDataManager* GetDataManager() const
    {
        return m_pDataManager;
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetCameraPosition
    ///
    /// @brief  Get camera position information data
    ///
    /// @param  pCameraPosition Fill camera position to be published
    ///
    /// @return CamxResultSuccess if successful
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult GetCameraPosition(
        UINT* pCameraPosition);

protected:
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ~ImageSensorModuleData
    ///
    /// @brief  Destructor
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ~ImageSensorModuleData();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ImageSensorModuleData
    ///
    /// @brief  Constructor
    ///
    /// @param  pSensorModuleManagerObj pointer to sensor module manager object
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    explicit ImageSensorModuleData(
        ImageSensorModuleSetManager* pSensorModuleManagerObj);

private:

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Initialize
    ///
    /// @brief  Initialize internal data structures for the ImageSensorModuleData
    ///
    /// @return CamxResultSuccess if successful
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult Initialize();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetActuatorDriverDataObj
    ///
    /// @brief  Gets the pointer to actuator driver data object
    ///
    /// @return Pointer to ActuatorDriverData
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ActuatorDriverData* GetActuatorDriverDataObj();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetOisDriverDataObj
    ///
    /// @brief  Gets the pointer to ois driver data object
    ///
    /// @return Pointer to OisDriverData
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    OISDriverData* GetOisDriverDataObj();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetEEPROMDriverDataObj
    ///
    /// @brief  Gets the pointer to EEPROM driver data object
    ///
    /// @return Pointer to EepromDriverData
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    EEPROMDriverData* GetEEPROMDriverDataObj();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetSensorDriverDataObj
    ///
    /// @brief  Gets the pointer to sensor driver data object
    ///
    /// @return Pointer to SensorDriverData
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    SensorDriverData* GetSensorDriverDataObj();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetCameraModuleDataObj
    ///
    /// @brief  Gets the pointer to camera module data object
    ///
    /// @return Pointer to CameraModuleData
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CameraModuleData* GetCameraModuleDataObj();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetFlashDriverDataObj
    ///
    /// @brief  Gets the pointer to flash driver data object
    ///
    /// @return Pointer to SensorDriverData
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FlashDriverData* GetFlashDriverDataObj();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetPDAFConfigDataObj
    ///
    /// @brief  Gets the pointer to PDAF configuration data object
    ///
    /// @return Pointer to PDAFConfigurationData
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    PDAFConfigurationData* GetPDAFConfigDataObj() const;

    ImageSensorModuleData(const ImageSensorModuleData&)            = delete;  ///< Disallow the copy constructor.
    ImageSensorModuleData& operator=(const ImageSensorModuleData&) = delete;  ///< Disallow assignment operator.

    UINT32                          m_usedModuleId;                             ///< The id of used module.
    ImageSensorModuleDataManager*   m_pDataManager;                             ///< Pointer to the data manager class
    ImageSensorModuleSetManager*    m_pSensorModuleManagerObj;                  ///< Pointer to sensor module manager object
    ImageSensorData*                m_pSensorData;                              ///< Pointer to image sensor data class
    ActuatorData*                   m_pActuatorData;                            ///< Pointer to actuator data class
    OISData*                        m_pOISData;                                 ///< Pointer to ois data class
    CameraModuleData*               m_pCameraModuleData;                        ///< Pointer to camera module data structure
    FlashData*                      m_pFlashData;                               ///< Pointer to flash data
    PDAFData*                       m_pPDAFData;                                ///< Pointer to PDAF data class
};

CAMX_NAMESPACE_END

#endif // CAMXIMAGESENSORMODULEDATA_H
